Constraint CNF: SAT and CSP Language Under One Roof

A new language, called constraint CNF, is proposed. It integrates propositional logic with constraints stemming from constraint programming. A family of algorithms is designed to solve problems expressed in constraint CNF. These algorithms build on techniques from both propositional satisfiability and constraint programming. The result is a uniform language and an algorithmic framework, which allow us to gain a deeper understanding of the relation between the solving techniques used in propositional satisfiability and in constraint programming and apply them together

Lazy Model Expansion: Interleaving Grounding with Search

Finding satisfying assignments for the variables involved in a set of constraints can be cast as a (bounded) model generation problem: search for (bounded) models of a theory in some logic. The state-of-the-art approach for bounded model generation for rich knowledge representation languages, like ASP, FO(.) and Zinc, is ground-and-solve: reduce the theory to a ground or propositional one and apply a search algorithm to the resulting theory. An important bottleneck is the blowup of the size of the theory caused by the reduction phase. Lazily grounding the theory during search is a way to overcome this bottleneck. We present a theoretical framework and an implementation in the context of the FO(.) knowledge representation language. Instead of grounding all parts of a theory, justifications are derived for some parts of it. Given a partial assignment for the grounded part of the theory and valid justifications for the formulas of the non-grounded part, the justifications provide a recipe to construct a complete assignment that satisfies the non-grounded part. When a justification for a particular formula becomes invalid during search, a new one is derived; if that fails, the formula is split in a part to be grounded and a part that can be justified. The theoretical framework captures existing approaches for tackling the grounding bottleneck such as lazy clause generation and grounding-on-the-fly, and presents a generalization of the 2-watched literal scheme. We present an algorithm for lazy model expansion and integrate it in a model generator for FO(ID), a language extending first-order logic with inductive definitions. The algorithm is implemented as part of the state-of-the-art FO(ID) Knowledge-Base System IDP. Experimental results illustrate the power and generality of the approach

FO(FD): Extending classical logic with rule-based fixpoint definitions

We introduce fixpoint definitions, a rule-based reformulation of fixpoint constructs. The logic FO(FD), an extension of classical logic with fixpoint definitions, is defined. We illustrate the relation between FO(FD) and FO(ID), which is developed as an integration of two knowledge representation paradigms. The satisfiability problem for FO(FD) is investigated by first reducing FO(FD) to difference logic and then using solvers for difference logic. These reductions are evaluated in the computation of models for FO(FD) theories representing fairness conditions and we provide potential applications of FO(FD).Comment: Presented at ICLP 2010. 16 pages, 1 figur

Separating Knowledge from Computation: An FO(.) Knowledge Base System and its Model Expansion Inference (Kennis scheiden van berekening: een FO(.) kennisbanksysteem en zijn modelexpansie inferentie)

The field of Knowledge Representation is devoted to the study of how knowledge can be represented and how it can be used for automated reasoning. A recently proposed approach is the Knowledge Base System paradigm, based on the idea that knowledge is not inherently linked to a specific reasoning task. Instead, the paradigm proposes to express knowledge in a truly declarative language and to accomplish different computational tasks by applying the proper inference to the represented knowledge.In my dissertation, we developed the knowledge base system IDP, intended as a laboratory for the study of software engineering in the context of the KBS paradigm. The aim is to provide a language in which a user can naturally model his applications and to provide robust inference engines that free the user from performance considerations. IDP combines a rich declarative language (an extension of classical logic) with a range of inference engines (for deduction, model expansion, propagation, querying, etc.) and an integration with a procedural language.In the second part of the work, we studied the core inference task of (optimal) model expansion, the task of finding (optimal) models of a logical theory expanding a given structure. Specifically, we developed techniques to address the long-standing instantiation problem: Traditionally, the input theory is transformed into an equivalent propositional theory in an initial grounding phase, after which a search algorithm is applied; however, the grounding phase causes a blowup of the size of the theory, which makes the approach infeasible for many practical applications. We developed several techniques to address the instantiation problem: (i) add support for function symbols in the search algorithm, (ii) detect and exploit implicit functional dependencies and (iii) tightly interleave grounding and search, by maintaining justifications of non-ground parts of the theory. The result is a state-of-the-art model expansion and optimization inference engine, which is among the best MiniZinc and ASP systems.status: publishe

Detection and exploitation of functional dependencies for model generation

Recent work in Answer Set Programming has integrated ideas from Constraint Programming. This has led to a new field called ASP Modulo CSP (CASP), in which the ASP language is enriched with constraint atoms representing constraint satisfaction problems. These constraints have a more compact grounding and are handled by a new generation of search algorithms. However, the burden is on the modeler to exploit these new constructs in his declarative problem specifications. Here, we explore how to remove this burden by automatically generating constraint atoms. We do so in the context of FO(·)-IDP, a knowledge representation language that extends first-order logic with, among others, inductive definitions, arithmetic and aggregates. We uncover functional dependencies in declarative problem specifications with a theorem prover and exploit them with a transformation that introduces functions. Experimental evaluation shows that we obtain more compact groundings and better search performance.status: publishe

DPLL(Agg): An efficient SMT module for aggregates

The use of aggregates often allow for a compact and natural encoding of many real-life problems. FO(Agg) is an extension of first order logic (FO) with aggregates. In this paper, we present algorithms for a satisfiability checking module for aggregate expressions in the context of the DPLL(T) architecture, achieving bound consistency. We consider among others cardinality, sum and maximum aggregates. The module can be used in all DPLL-based SAT, SMT and ASP solvers. The algorithms have a low complexity. We report on the incorporation of the algorithms in Minisat and the IDP-system, including an experimental evaluation.status: publishe

Constraint CNF: a SAT and CSP Language Under One Roof

A new language, called constraint CNF, is proposed. It integrates propositional logic with constraints stemming from constraint programming (CP). A family of algorithms is designed to solve problems expressed in constraint CNF. These algorithms build on techniques from both propositional satisfiability (SAT) and CP. The result is a uniform language and an algorithmic framework, which allow us to gain a deeper understanding of the relation between the solving techniques used in SAT and in CP and apply them together